// pages/task-detail/index.js

import {
  getCurrentUserId
} from '../../../utils/user-helper.js';
import { isTokenExpiredError, handleTokenExpiredError, checkAndHandleAuthError } from '../../../utils/auth-error-handler.js';

Page({
  /**
   * 页面的初始数据
   */
  data: {
    taskId: '',
    task: null,
    refreshing: false,
    createTime: '',
    updateTime: '',
    showParams: true, // 控制参数面板的展开/折叠
    fromPage: 'list', // 记录来源页面
    downloadTask: null, // 🆕 保存下载任务引用，用于页面离开时终止下载

  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    const {
      taskId,
      from
    } = options;
    if (!taskId) {
      wx.showToast({
        title: '任务ID不能为空',
        icon: 'none'
      });
      wx.navigateBack();
      return;
    }

    this.setData({
      taskId,
      fromPage: from || 'list' // 记录来源页面，默认为list
    });

    // 云开发应该在app.js中全局初始化，这里不需要重复初始化
    this.loadTaskDetail();
  },

  /**
   * 🆕 生命周期函数--监听页面卸载
   */
  onUnload() {
    // 页面离开时终止正在进行的下载
    if (this.data.downloadTask) {
      console.log('页面离开，终止下载任务');
      try {
        this.data.downloadTask.abort();
        wx.hideLoading();
        wx.showToast({
          title: '下载已取消',
          icon: 'none',
          duration: 1500
        });
      } catch (error) {
        console.warn('终止下载任务失败:', error);
      }
      
      // 清除下载任务引用
      this.setData({
        downloadTask: null
      });
    }
  },


  // 加载任务详情
  async loadTaskDetail(showLoading = true) {
    try {
      // 减少不必要的loading显示，避免界面卡顿
      if (showLoading) {
        // 使用较短的延迟显示loading，如果请求很快就不显示了
        const loadingTimer = setTimeout(() => {
          wx.showLoading({
            title: '加载中...',
            mask: true
          });
        }, 200);

        // 保存timer用于后续清除
        this.loadingTimer = loadingTimer;
      }

      // 获取当前用户ID
      const userId = getCurrentUserId();
      if (!userId) {
        wx.showToast({
          title: '请先登录',
          icon: 'none'
        });
        if (showLoading) wx.hideLoading();
        return;
      }

      const result = await wx.cloud.callFunction({
        name: 'video-task',
        data: {
          action: 'query',
          userId: userId,
          data: {
            taskId: this.data.taskId
          }
        },
        timeout: 10000 // 进一步减少超时时间到10秒，避免长时间等待
      });

      // 检查是否为token过期错误
      if (checkAndHandleAuthError(result, {
        customMessage: '任务访问权限已过期，请重新登录'
      })) {
        if (showLoading) wx.hideLoading();
        return;
      }

      if (result.result.success) {
        const task = result.result.data;
        // 简化调试信息
        console.log('任务详情加载完成:', task.taskId, task.status);

        // 处理任务数据，添加显示所需的字段
        const processedTask = {
          ...task,
          displayStatus: task.status === 'rendering' ? 'running' : task.status,
          detail_content: task.parameters.content || task.parameters.topic || "默认内容"
        };

        this.setData({
          task: processedTask,
          createTime: this.formatTime(task.createdAt),
          updateTime: task.updatedAt ? this.formatTime(task.updatedAt) : ''
        });


      } else {
        throw new Error(result.result.error || '加载任务详情失败');
      }
    } catch (error) {
      console.error('加载任务详情失败:', error);
      wx.showToast({
        title: error.message || '加载失败',
        icon: 'none'
      });
    } finally {
      // 清除loading timer
      if (this.loadingTimer) {
        clearTimeout(this.loadingTimer);
        this.loadingTimer = null;
      }
      wx.hideLoading();
    }
  },

  // 刷新任务状态 - 使用专门的refresh action强制查询coze并更新数据库
  async refreshStatus() {
    if (this.data.refreshing) return;

    this.setData({
      refreshing: true
    });

    try {

      const res = await wx.cloud.callFunction({
        name: 'video-task',
        data: {
          action: 'refresh', // 使用专门的refresh action强制查询coze
          data: {
            taskId: this.data.taskId
          }
        }
      });

      // 检查是否为token过期错误
      if (checkAndHandleAuthError(res, {
        customMessage: '任务访问权限已过期，请重新登录'
      })) {
        this.setData({ refreshing: false });
        return;
      }

      console.log('📋 云函数完整响应:', JSON.stringify(res, null, 2));
      console.log('📋 响应结果:', res.result);
      console.log('📋 响应错误信息:', res.errMsg);

      if (res.result && res.result.success) {
        const task = res.result.data;
        const updated = res.result.updated;
        const refreshError = res.result.refreshError;
        const debugInfo = res.result.debugInfo;


        // 处理任务数据，添加显示所需的字段
        const processedTask = {
          ...task,
          displayStatus: task.status === 'rendering' ? 'running' : task.status,
          detail_content: task.parameters.content || task.parameters.topic || "默认内容"
        };

        this.setData({
          task: processedTask,
          createTime: this.formatTime(task.createdAt || task.createTime),
          updateTime: task.updatedAt ? this.formatTime(task.updatedAt) : (task.updateTime ? this.formatTime(task.updateTime) : '')
        });

        // 根据刷新结果显示不同提示
        if (refreshError) {
          wx.showToast({
            title: `刷新失败: ${refreshError}`,
            icon: 'none',
            duration: 3000
          });
          console.log('⚠️ 任务刷新出错:', refreshError);
        } else if (updated) {
          wx.showToast({
            title: '状态已更新',
            icon: 'success'
          });
          console.log('✅ 任务状态已更新');
        } else {
          // 显示调试信息而不是简单的"状态无变化"
          let message = '状态无变化';
          if (debugInfo && debugInfo.step3_cozeQuery && debugInfo.step3_cozeQuery.skipped) {
            message = '任务已完成';
          } else if (debugInfo && debugInfo.step4_statusUpdate && debugInfo.step4_statusUpdate.reason) {
            message = debugInfo.step4_statusUpdate.reason;
          }

          wx.showToast({
            title: message,
            icon: 'none'
          });
          console.log('ℹ️ 任务状态:', message);
        }
      } else {
        console.error('❌ 刷新任务失败 - 完整响应:', JSON.stringify(res, null, 2));
        console.error('❌ 刷新任务失败 - 结果:', res.result);
        console.error('❌ 刷新任务失败 - 错误信息:', res.errMsg);

        const errorMessage = res.result?.error || '刷新失败，请重试';
        wx.showModal({
          title: '刷新失败',
          content: errorMessage,
          showCancel: false,
          confirmText: '确定'
        });
      }
    } catch (error) {
      console.error('❌ 刷新任务异常 - 完整错误:', error);
      console.error('❌ 刷新任务异常 - 错误消息:', error.message);
      console.error('❌ 刷新任务异常 - 错误堆栈:', error.stack);
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      });
    } finally {
      this.setData({
        refreshing: false
      });
    }
  },

  copyLink() {
    wx.setClipboardData({
      data: this.data.url,
      success() {
        wx.showToast({
          title: '链接已复制',
          icon: 'success'
        });
      }
    });
  },
  // 优化版下载函数：解决Android文件类型识别和超时问题
  // 在 downloadVideo 函数开始处添加清理逻辑
  async downloadVideo() {
    const { task } = this.data;
    if (!task?.result?.videoUrl) {
      wx.showToast({ title: '没有视频可下载', icon: 'none' });
      return;
    }

    const videoUrl = task.result.videoUrl || task.result.video_url;

    // 🔧 清理存储空间，解决存储限制问题
    try {
      wx.showLoading({ title: '清理缓存...', mask: true });
      await this.clearStorageSpace();
      
      // 🔧 增加等待时间，确保清理完全完成
      console.log('清理完成，等待2秒确保文件系统同步...');
      await new Promise(resolve => setTimeout(resolve, 2000));
      
      wx.hideLoading();
      this.startDownload(videoUrl);
      
    } catch (error) {
      console.error('清理存储失败:', error);
      wx.hideLoading();
      // 即使清理失败也尝试下载
      this.startDownload(videoUrl);
    }
  },

  // 🔧 清理存储空间（改进版 - 等待所有删除操作完成）
  async clearStorageSpace() {
    console.log('=== 开始清理存储空间 ===');
    
    // 1. 清理本地存储文件（10MB 限制）- 使用 Promise 等待完成
    await new Promise((resolve) => {
      wx.getSavedFileList({
        success: (res) => {
          console.log('本地存储文件列表:', res.fileList);
          
          if (res.fileList && res.fileList.length > 0) {
            let deleteCount = 0;
            const totalFiles = res.fileList.length;
            console.log(`开始删除 ${totalFiles} 个本地存储文件`);
            
            // 删除所有本地存储的文件
            res.fileList.forEach((file) => {
              wx.removeSavedFile({
                filePath: file.filePath,
                success: () => {
                  console.log('删除本地存储文件成功:', file.filePath);
                  deleteCount++;
                  if (deleteCount === totalFiles) {
                    console.log('✅ 所有本地存储文件删除完成');
                    resolve();
                  }
                },
                fail: (err) => {
                  console.warn('删除本地存储文件失败:', file.filePath, err);
                  deleteCount++;
                  if (deleteCount === totalFiles) {
                    console.log('⚠️ 本地存储文件删除完成（部分失败）');
                    resolve();
                  }
                }
              });
            });
          } else {
            console.log('本地存储文件列表为空');
            resolve();
          }
        },
        fail: (err) => {
          console.warn('获取本地存储文件列表失败:', err);
          resolve();
        }
      });
    });

    // 2. 清理用户数据目录 - 也使用 Promise 等待完成
    await new Promise((resolve) => {
      wx.getFileSystemManager().readdir({
        dirPath: wx.env.USER_DATA_PATH,
        success: (res) => {
          console.log('用户数据目录文件:', res.files);
          
          const videoFiles = res.files.filter(fileName => 
            fileName.includes('video_') || fileName.endsWith('.mp4') || fileName.endsWith('.mov')
          );
          
          if (videoFiles.length > 0) {
            let deleteCount = 0;
            console.log(`开始删除 ${videoFiles.length} 个用户数据文件`);
            
            videoFiles.forEach((fileName) => {
              wx.getFileSystemManager().unlink({
                filePath: wx.env.USER_DATA_PATH + '/' + fileName,
                success: () => {
                  console.log('删除用户数据文件成功:', fileName);
                  deleteCount++;
                  if (deleteCount === videoFiles.length) {
                    console.log('✅ 所有用户数据文件删除完成');
                    resolve();
                  }
                },
                fail: (err) => {
                  console.warn('删除用户数据文件失败:', fileName, err);
                  deleteCount++;
                  if (deleteCount === videoFiles.length) {
                    console.log('⚠️ 用户数据文件删除完成（部分失败）');
                    resolve();
                  }
                }
              });
            });
          } else {
            console.log('用户数据目录无视频文件');
            resolve();
          }
        },
        fail: (err) => {
          console.warn('读取用户数据目录失败:', err);
          resolve();
        }
      });
    });

    // 3. ⚠️ 不清理本地数据存储，保护用户登录信息和设置
    // wx.clearStorage(); // ❌ 已移除：这会清除用户登录信息等重要数据
    console.log('✅ 跳过本地数据存储清理，保护用户数据');

    console.log('=== 存储清理完成 ===');
  },

  // 🔧 实际下载函数（简化版，基于官方示例）
  async startDownload(videoUrl) {
    // 🔍 检查当前存储状态（调试信息）
    try {
      console.log('=== 下载前存储状态检查 ===');
      
      // 检查本地数据存储
      const storageInfo = wx.getStorageInfoSync();
      console.log('本地数据存储状态:', {
        keys: storageInfo.keys.length + '个key',
        currentSize: storageInfo.currentSize + 'KB',
        limitSize: storageInfo.limitSize + 'KB',
        freeSpace: (storageInfo.limitSize - storageInfo.currentSize) + 'KB',
        usagePercent: ((storageInfo.currentSize / storageInfo.limitSize) * 100).toFixed(1) + '%'
      });
      
      // 检查本地存储文件
      wx.getSavedFileList({
        success: (res) => {
          console.log('本地存储文件状态:', {
            fileCount: res.fileList.length + '个文件',
            files: res.fileList.map(file => ({
              path: file.filePath,
              size: file.size ? (file.size / 1024 / 1024).toFixed(2) + 'MB' : '未知大小',
              createTime: file.createTime ? new Date(file.createTime * 1000).toLocaleString() : '未知时间'
            }))
          });
          
          let totalSize = 0;
          res.fileList.forEach(file => {
            totalSize += file.size || 0;
          });
          console.log('本地存储文件总大小:', (totalSize / 1024 / 1024).toFixed(2) + 'MB');
        },
        fail: (err) => {
          console.warn('获取本地存储文件列表失败:', err);
        }
      });
      
      // 检查用户数据目录
      wx.getFileSystemManager().readdir({
        dirPath: wx.env.USER_DATA_PATH,
        success: (res) => {
          const videoFiles = res.files.filter(fileName => 
            fileName.includes('video_') || fileName.endsWith('.mp4') || fileName.endsWith('.mov')
          );
          console.log('用户数据目录状态:', {
            totalFiles: res.files.length + '个文件',
            videoFiles: videoFiles.length + '个视频文件',
            videoFileNames: videoFiles
          });
        },
        fail: (err) => {
          console.warn('读取用户数据目录失败:', err);
        }
      });
      
      console.log('=== 存储状态检查完成 ===');
    } catch (error) {
      console.error('检查存储状态失败:', error);
    }

    // 检查相册权限
    try {
      const setting = await wx.getSetting();
      if (!setting.authSetting['scope.writePhotosAlbum']) {
        try {
          await wx.authorize({ scope: 'scope.writePhotosAlbum' });
        } catch (err) {
          wx.showModal({
            title: '权限提醒',
            content: '需要您授权保存相册',
            showCancel: false,
            success: () => {
              wx.openSetting({
                success: (settingdata) => {
                  if (settingdata.authSetting['scope.writePhotosAlbum']) {
                    wx.showModal({
                      title: '提示',
                      content: '获取权限成功,再次点击下载即可保存',
                      showCancel: false,
                    });
                  } else {
                    wx.showModal({
                      title: '提示',
                      content: '获取权限失败，将无法保存到相册哦~',
                      showCancel: false,
                    });
                  }
                }
              });
            }
          });
          return;
        }
      }
    } catch (error) {
      console.error('权限检查失败:', error);
      return;
    }

    // 获取文件扩展名并生成文件路径（使用官方示例格式）
    const extension = this.getVideoExtension(videoUrl);
    const fileName = new Date().valueOf(); // 使用官方示例的文件名格式
    const filePath = wx.env.USER_DATA_PATH + '/' + fileName + '.' + extension;

    console.log('开始下载视频:', {
      url: videoUrl,
      extension: extension,
      fileName: fileName,
      filePath: filePath
    });

    // 开始下载
    wx.showLoading({ title: '准备下载...', mask: true });

    const downloadTask = wx.downloadFile({
      url: videoUrl,
      filePath: filePath,
      timeout: 120000,
      success: async (res) => {
        // 🆕 下载完成，清除任务引用
        this.setData({ downloadTask: null });
        
        if (res.statusCode === 200) {
          console.log('下载成功:', res);

          // 直接保存到相册，不需要 getVideoInfo 验证
          wx.saveVideoToPhotosAlbum({
            filePath: res.filePath,
            success: () => {
              wx.hideLoading();
              wx.showModal({
                title: '下载成功',
                content: `视频已保存到相册 🎉\n格式: ${extension.toUpperCase()}`,
                showCancel: false,
                confirmText: '好的',
                confirmColor: '#07C160',
              });
            },
            fail: (err) => {
              wx.hideLoading();
              console.error('保存到相册失败:', err);

              // 使用官方示例的权限处理逻辑
              if (err.errMsg === 'saveVideoToPhotosAlbum:fail auth deny') {
                wx.showModal({
                  title: '提示',
                  content: '需要您授权保存相册',
                  showCancel: false,
                  success: () => {
                    wx.openSetting({
                      success: (settingdata) => {
                        if (settingdata.authSetting['scope.writePhotosAlbum']) {
                          wx.showModal({
                            title: '提示',
                            content: '获取权限成功,再次点击下载即可保存',
                            showCancel: false,
                          });
                        } else {
                          wx.showModal({
                            title: '提示',
                            content: '获取权限失败，将无法保存到相册哦~',
                            showCancel: false,
                          });
                        }
                      }
                    });
                  }
                });
              } else {
                // 其他错误的详细处理
                console.error('=== 保存到相册失败详细信息 ===');
                console.error('完整错误对象:', err);
                console.error('错误消息:', err.errMsg);
                console.error('文件路径:', res.filePath);
                console.error('文件扩展名:', extension);
                
                let errorMsg = '保存失败';
                let errorDetails = err.errMsg || '未知错误';
                
                if (err.errMsg && err.errMsg.includes('invalid file type')) {
                  errorMsg = 'Android设备文件格式不支持';
                  errorDetails = `检测到的格式: ${extension.toUpperCase()}\n建议：尝试使用其他播放器观看\n\n完整错误: ${err.errMsg}`;
                } else if (err.errMsg && err.errMsg.includes('size')) {
                  errorMsg = '文件大小限制';
                  errorDetails = `文件可能过大，微信限制保存到相册的视频大小\n\n完整错误: ${err.errMsg}`;
                } else if (err.errMsg && err.errMsg.includes('storage')) {
                  errorMsg = '存储空间不足';
                  errorDetails = `设备存储空间不足或微信存储限制\n\n完整错误: ${err.errMsg}`;
                }
                
                wx.showModal({
                  title: errorMsg,
                  content: errorDetails,
                  confirmText: '重试',
                  cancelText: '取消',
                  success: (modalRes) => {
                    if (modalRes.confirm) {
                      this.downloadVideo();
                    }
                  }
                });
              }
            }
          });
        } else {
          wx.hideLoading();
          wx.showModal({
            title: '下载失败',
            content: `服务器响应异常 (状态码: ${res.statusCode})`,
            confirmText: '重试',
            cancelText: '取消',
            success: (modalRes) => {
              if (modalRes.confirm) {
                this.downloadVideo();
              }
            }
          });
        }
      },
      fail: (err) => {
        // 🆕 下载失败，清除任务引用
        this.setData({ downloadTask: null });
        
        wx.hideLoading();
        
        // 🔧 详细的下载失败错误处理
        console.error('=== 下载失败详细信息 ===');
        console.error('完整错误对象:', err);
        console.error('错误消息:', err.errMsg);
        console.error('视频URL:', videoUrl);
        console.error('文件路径:', filePath);
        
        let errorTitle = '下载失败';
        let errorContent = err.errMsg || '下载失败，请重试';
        let showRetry = true;
        
        // 🔧 特殊处理存储限制错误
        if (err.errMsg && err.errMsg.includes('storage limit is exceeded')) {
          errorTitle = '存储空间不足';
          errorContent = `微信小程序存储空间已满\n\n错误详情: ${err.errMsg}\n\n解决方案:\n1. 已自动清理缓存，请重试\n2. 如仍失败，请重启小程序`;
        } else if (err.errMsg && err.errMsg.includes('size')) {
          errorTitle = '文件大小限制';
          errorContent = `文件大小超出限制\n\n错误详情: ${err.errMsg}`;
        } else if (err.errMsg && err.errMsg.includes('timeout')) {
          errorTitle = '下载超时';
          errorContent = `下载超时，可能是网络较慢或文件较大\n\n错误详情: ${err.errMsg}`;
        } else if (err.errMsg && err.errMsg.includes('domain')) {
          errorTitle = '域名限制';
          errorContent = `下载域名受限，请联系管理员\n\n错误详情: ${err.errMsg}`;
          showRetry = false;
        }
        
        wx.showModal({
          title: errorTitle,
          content: errorContent,
          confirmText: showRetry ? '重试' : '确定',
          cancelText: showRetry ? '取消' : '',
          showCancel: showRetry,
          success: (modalRes) => {
            if (modalRes.confirm && showRetry) {
              this.downloadVideo();
            }
          }
        });
      }
    });

    // 🆕 保存下载任务引用，用于页面离开时终止下载
    this.setData({ downloadTask: downloadTask });
    console.log('下载任务已开始，任务引用已保存');

    // 进度监听
    downloadTask.onProgressUpdate((progressRes) => {
      const progress = progressRes.progress;
      if (progress > 0) {
        wx.showLoading({
          title: `下载中 ${progress}%`,
          mask: true
        });
      }
    });
  },

  // 云函数备用下载方案（原来的方式）
  async downloadVideoViaCloud() {
    const { task } = this.data;
    wx.showLoading({ title: '备用方式下载中...', mask: true });

    try {
      // 调用云函数下载
      const res = await wx.cloud.callFunction({
        name: 'proxyDownload',
        data: { url: task.result.videoUrl },
      });

      if (!res.result?.success) {
        throw new Error(res.result?.msg || '云函数下载失败');
      }

      // 从云存储下载
      const downRes = await wx.cloud.downloadFile({
        fileID: res.result.fileID
      });

      // 保存到相册
      await wx.saveVideoToPhotosAlbum({
        filePath: downRes.tempFilePath
      });

      wx.hideLoading();
      wx.showModal({
        title: '下载成功',
        content: '视频已保存到相册 🎉',
        showCancel: false,
        confirmText: '好的',
        confirmColor: '#07C160',
      });
    } catch (err) {
      wx.hideLoading();
      console.error('备用方案也失败:', err);
      wx.showModal({
        title: '下载失败',
        content: err.message || '两种下载方式都失败了，请检查网络后重试',
        confirmText: '重试',
        cancelText: '取消',
        success: (modalRes) => {
          if (modalRes.confirm) {
            this.downloadVideo(); // 重新尝试（从原生开始）
          }
        }
      });
    }
  },

  // 👇 判断相册权限是否已开启
  async checkPhotoPermission() {
    try {
      const setting = await wx.getSetting();
      // 判断是否已经有权限
      if (setting.authSetting['scope.writePhotosAlbum']) {
        return true; // ✅ 已授权
      }
      return false; // ❌ 尚未授权
    } catch (e) {
      console.error('检查权限失败', e);
      return false;
    }
  },

  // 从URL中获取视频文件扩展名（处理带签名的URL）
  getVideoExtension(url) {
    try {
      // 先移除URL中的hash部分（如 #devtools_no_referrer）
      const urlWithoutHash = url.split('#')[0];

      // 再移除查询参数部分（?之后的内容）
      const pathPart = urlWithoutHash.split('?')[0];

      // 从路径中提取扩展名
      const pathSegments = pathPart.split('/');
      const fileName = pathSegments[pathSegments.length - 1];

      if (fileName && fileName.includes('.')) {
        const extension = fileName.split('.').pop().toLowerCase();

        // 验证是否为有效的视频扩展名
        const validVideoExtensions = ['mp4', 'mov', 'avi', 'wmv', 'flv', 'm4v', '3gp', 'mkv', 'webm'];
        if (validVideoExtensions.includes(extension)) {
          console.log('提取到视频扩展名:', extension, '来源URL:', url);
          return extension;
        }
      }

      // 如果无法提取有效扩展名，根据URL特征判断
      if (url.toLowerCase().includes('/video/quicktime/') || url.toLowerCase().includes('.mov')) {
        console.log('根据URL特征判断为MOV格式');
        return 'mov';
      } else if (url.toLowerCase().includes('/video/mp4/') || url.toLowerCase().includes('.mp4')) {
        console.log('根据URL特征判断为MP4格式');
        return 'mp4';
      }

      // 默认返回mp4
      console.log('无法确定扩展名，使用默认mp4格式');
      return 'mp4';
    } catch (error) {
      console.error('提取视频扩展名失败:', error);
      return 'mp4';
    }
  },

  // 生成随机文件名
  getRandomFileName(extension) {
    const timestamp = Date.now();
    const random = Math.floor(Math.random() * 10000);
    return `video_${timestamp}_${random}.${extension}`;
  },

  // 获取视频信息（Promise封装）
  getVideoInfo(filePath) {
    return new Promise((resolve, reject) => {
      wx.getVideoInfo({
        src: filePath,
        success: (res) => {
          console.log('视频信息获取成功:', res);
          resolve(res);
        },
        fail: (err) => {
          console.error('获取视频信息失败:', err);
          reject(err);
        }
      });
    });
  },

  // 切换参数面板显示
  toggleParams() {
    this.setData({
      showParams: !this.data.showParams
    });
  },



  // 分享视频
  shareVideo() {
    const {
      task
    } = this.data;
    if (!task || !task.result || !task.result.videoUrl) return;

    wx.showShareMenu({
      withShareTicket: true,
      menus: ['shareAppMessage', 'shareTimeline']
    });
  },

  // 预览视频 - 全屏播放
  previewVideo() {
    const { task } = this.data;
    if (!task || !task.result || !task.result.videoUrl) {
      wx.showToast({ title: '暂无视频', icon: 'none' });
      return;
    }

    const videoUrl = task.result.videoUrl;
    const isMovFormat = videoUrl.toLowerCase().includes('.mov');

    // 获取系统信息
    const systemInfo = wx.getSystemInfoSync();
    const isAndroid = systemInfo.platform === 'android';

    // Android + MOV 格式，给出友好提示
    if (isAndroid && isMovFormat) {
      wx.showModal({
        title: '格式提示',
        content: 'Android设备暂不支持MOV格式预览，建议：\n1. 下载视频到本地\n2. 使用其他播放器观看',
        confirmText: '下载视频',
        cancelText: '取消',
        confirmColor: '#07C160',
        success: (res) => {
          if (res.confirm) {
            this.downloadVideo();
          }
        }
      });
      return;
    }

    // 尝试直接预览
    wx.showLoading({ title: '加载中...' });

    wx.previewMedia({
      sources: [{
        url: videoUrl,
        type: 'video'
      }],
      current: 0,
      success: () => {
        wx.hideLoading();
        console.log('视频预览成功');
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('视频预览失败:', err);

        // 预览失败，提示下载
        wx.showModal({
          title: '预览失败',
          content: '无法直接预览该视频，是否下载到本地观看？',
          confirmText: '下载',
          cancelText: '取消',
          success: (modalRes) => {
            if (modalRes.confirm) {
              this.downloadVideo();
            }
          }
        });
      }
    });
  },

  // 备用视频预览方案
  fallbackVideoPreview() {
    const {
      task
    } = this.data;
    if (!task || !task.result || !task.result.videoUrl) return;

    wx.showLoading({
      title: '加载中...'
    });

    wx.downloadFile({
      url: task.result.videoUrl,
      success: (res) => {
        wx.hideLoading();
        if (res.statusCode === 200) {
          // 创建一个全屏视频组件
          wx.createVideoContext('preview-video', this).requestFullScreen({
            direction: 0
          });
        } else {
          wx.showToast({
            title: '视频加载失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('下载视频失败:', err);
        wx.showToast({
          title: '视频加载失败',
          icon: 'none'
        });
      }
    });
  },

  // 返回上一页
  goBack() {
    const fromPage = this.data.fromPage;

    if (fromPage === 'submit') {
      // 如果是从提交页面来的，直接跳转到任务列表页面
      wx.switchTab({
        url: '/pages/task-list/index'
      });
    } else {
      // 其他情况正常返回
      wx.navigateBack({
        delta: 1,
        fail: () => {
          // 如果返回失败，跳转到任务列表
          wx.switchTab({
            url: '/pages/task-list/index'
          });
        }
      });
    }
  },

  // 跳转到任务列表
  goToTaskList() {
    wx.navigateTo({
      url: '/pages/task-list/index'
    });
  },

  // 格式化时间
  formatTime(dateStr) {
    const date = new Date(dateStr);
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');

    return `${year}-${month}-${day} ${hours}:${minutes}`;
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    const {
      task
    } = this.data;
    return {
      title: 'AI生成的精彩视频',
      path: `/packageTask/pages/task-detail/index?taskId=${task.taskId}`,
      imageUrl: task.result && task.result.videoUrl ? task.result.videoUrl : ''
    };
  }
});